/*
 * jQuery Foundation Joyride Plugin 2.1
 * http://foundation.zurb.com
 * Copyright 2013, ZURB
 * Free to use under the MIT license.
 * http://www.opensource.org/licenses/mit-license.php
 */

/*jslint unparam: true, browser: true, indent: 2 */

;(function ($, window, undefined) {
    'use strict';

    var defaults = {
            'version'              : '2.1',
            'tipLocation'          : 'bottom',  // 'top' or 'bottom' in relation to parent
            'nubPosition'          : 'auto',    // override on a per tooltip bases
            'scroll'               : true,      // whether to scroll to tips
            'scrollSpeed'          : 300,       // Page scrolling speed in milliseconds
            'timer'                : 0,         // 0 = no timer , all other numbers = timer in milliseconds
            'autoStart'            : true,     // true or false - false tour starts when restart called
            'startTimerOnClick'    : true,      // true or false - true requires clicking the first button start the timer
            'startOffset'          : 0,         // the index of the tooltip you want to start on (index of the li)
            'nextButton'           : true,      // true or false to control whether a next button is used
            'tipAnimation'         : 'fade',    // 'pop' or 'fade' in each tip
            'pauseAfter'           : [],        // array of indexes where to pause the tour after
            'tipAnimationFadeSpeed': 300,       // when tipAnimation = 'fade' this is speed in milliseconds for the transition
            'cookieMonster'        : false,     // true or false to control whether cookies are used
            'cookieName'           : 'joyride', // Name the cookie you'll use
            'cookieDomain'         : false,     // Will this cookie be attached to a domain, ie. '.notableapp.com'
            'cookiePath'           : false,     // Set to '/' if you want the cookie for the whole website
            'localStorage'         : false,     // true or false to control whether localstorage is used
            'localStorageKey'      : 'joyride', // Keyname in localstorage
            'tipContainer'         : 'body',    // Where will the tip be attached
            'modal'                : false,     // Whether to cover page with modal during the tour
            'expose'               : false,     // Whether to expose the elements at each step in the tour (requires modal:true)
            'postExposeCallback'   : $.noop,    // A method to call after an element has been exposed
            'preRideCallback'      : $.noop,    // A method to call before the tour starts (passed index, tip, and cloned exposed element)
            'postRideCallback'     : $.noop,    // A method to call once the tour closes (canceled or complete)
            'preStepCallback'      : $.noop,    // A method to call before each step
            'postStepCallback'     : $.noop,    // A method to call after each step
            'template' : { // HTML segments for tip layout
                'link'    : '<a href="#close" class="joyride-close-tip">X</a>',
                'timer'   : '<div class="joyride-timer-indicator-wrap"><span class="joyride-timer-indicator"></span></div>',
                'tip'     : '<div class="joyride-tip-guide"><span class="joyride-nub"></span></div>',
                'wrapper' : '<div class="joyride-content-wrapper" role="dialog"></div>',
                'button'  : '<a href="#" class="joyride-next-tip"></a>',
                'modal'   : '<div class="joyride-modal-bg"></div>',
                'expose'  : '<div class="joyride-expose-wrapper"></div>',
                'exposeCover': '<div class="joyride-expose-cover"></div>'
            }
        },

        Modernizr = Modernizr || false,

        settings = {},

        methods = {

            init : function (opts) {
                return this.each(function () {

                    if ($.isEmptyObject(settings)) {
                        settings = $.extend(true, defaults, opts);

                        // non configurable settings
                        settings.document = window.document;
                        settings.$document = $(settings.document);
                        settings.$window = $(window);
                        settings.$content_el = $(this);
                        settings.$body = $(settings.tipContainer);
                        settings.body_offset = $(settings.tipContainer).position();
                        settings.$tip_content = $('> li', settings.$content_el);
                        settings.paused = false;
                        settings.attempts = 0;

                        settings.tipLocationPatterns = {
                            top: ['bottom'],
                            bottom: [], // bottom should not need to be repositioned
                            left: ['right', 'top', 'bottom'],
                            right: ['left', 'top', 'bottom']
                        };

                        // are we using jQuery 1.7+
                        methods.jquery_check();

                        // can we create cookies?
                        if (!$.isFunction($.cookie)) {
                            settings.cookieMonster = false;
                        }

                        // generate the tips and insert into dom.
                        if ( (!settings.cookieMonster || !$.cookie(settings.cookieName) ) &&
                            (!settings.localStorage || !methods.support_localstorage() || !localStorage.getItem(settings.localStorageKey) ) ) {

                            settings.$tip_content.each(function (index) {
                                methods.create({$li : $(this), index : index});
                            });

                            // show first tip
                            if(settings.autoStart)
                            {
                                if (!settings.startTimerOnClick && settings.timer > 0) {
                                    methods.show('init');
                                    methods.startTimer();
                                } else {
                                    methods.show('init');
                                }
                            }

                        }

                        settings.$document.on('click.joyride', '.joyride-next-tip, .joyride-modal-bg', function (e) {
                            e.preventDefault();

                            if (settings.$li.next().length < 1) {
                                methods.end();
                            } else if (settings.timer > 0) {
                                clearTimeout(settings.automate);
                                methods.hide();
                                methods.show();
                                methods.startTimer();
                            } else {
                                methods.hide();
                                methods.show();
                            }

                        });

                        settings.$document.on('click.joyride', '.joyride-close-tip', function (e) {
                            e.preventDefault();
                            methods.end();
                        });

                        settings.$window.bind('resize.joyride', function (e) {
                            if(settings.$li){
                                if(settings.exposed && settings.exposed.length>0){
                                    var $els = $(settings.exposed);
                                    $els.each(function(){
                                        var $this = $(this);
                                        methods.un_expose($this);
                                        methods.expose($this);
                                    });
                                }
                                if (methods.is_phone()) {
                                    methods.pos_phone();
                                } else {
                                    methods.pos_default();
                                }
                            }
                        });
                    } else {
                        methods.restart();
                    }

                });
            },

            // call this method when you want to resume the tour
            resume : function () {
                methods.set_li();
                methods.show();
            },

            nextTip: function(){
                if (settings.$li.next().length < 1) {
                    methods.end();
                } else if (settings.timer > 0) {
                    clearTimeout(settings.automate);
                    methods.hide();
                    methods.show();
                    methods.startTimer();
                } else {
                    methods.hide();
                    methods.show();
                }
            },

            tip_template : function (opts) {
                var $blank, content, $wrapper;

                opts.tip_class = opts.tip_class || '';

                $blank = $(settings.template.tip).addClass(opts.tip_class);
                content = $.trim($(opts.li).html()) +
                    methods.button_text(opts.button_text) +
                    settings.template.link +
                    methods.timer_instance(opts.index);

                $wrapper = $(settings.template.wrapper);
                if (opts.li.attr('data-aria-labelledby')) {
                    $wrapper.attr('aria-labelledby', opts.li.attr('data-aria-labelledby'))
                }
                if (opts.li.attr('data-aria-describedby')) {
                    $wrapper.attr('aria-describedby', opts.li.attr('data-aria-describedby'))
                }
                $blank.append($wrapper);
                $blank.first().attr('data-index', opts.index);
                $('.joyride-content-wrapper', $blank).append(content);

                return $blank[0];
            },

            timer_instance : function (index) {
                var txt;

                if ((index === 0 && settings.startTimerOnClick && settings.timer > 0) || settings.timer === 0) {
                    txt = '';
                } else {
                    txt = methods.outerHTML($(settings.template.timer)[0]);
                }
                return txt;
            },

            button_text : function (txt) {
                if (settings.nextButton) {
                    txt = $.trim(txt) || 'Next';
                    txt = methods.outerHTML($(settings.template.button).append(txt)[0]);
                } else {
                    txt = '';
                }
                return txt;
            },

            create : function (opts) {
                // backwards compatibility with data-text attribute
                var buttonText = opts.$li.attr('data-button') || opts.$li.attr('data-text'),
                    tipClass = opts.$li.attr('class'),
                    $tip_content = $(methods.tip_template({
                        tip_class : tipClass,
                        index : opts.index,
                        button_text : buttonText,
                        li : opts.$li
                    }));

                $(settings.tipContainer).append($tip_content);
            },

            show : function (init) {
                var opts = {}, ii, opts_arr = [], opts_len = 0, p,
                    $timer = null;

                // are we paused?
                if (settings.$li === undefined || ($.inArray(settings.$li.index(), settings.pauseAfter) === -1)) {

                    // don't go to the next li if the tour was paused
                    if (settings.paused) {
                        settings.paused = false;
                    } else {
                        methods.set_li(init);
                    }

                    settings.attempts = 0;

                    if (settings.$li.length && settings.$target.length > 0) {
                        if(init){ //run when we first start
                            settings.preRideCallback(settings.$li.index(), settings.$next_tip );
                            if(settings.modal){
                                methods.show_modal();
                            }
                        }
                        settings.preStepCallback(settings.$li.index(), settings.$next_tip );

                        // parse options
                        opts_arr = (settings.$li.data('options') || ':').split(';');
                        opts_len = opts_arr.length;
                        for (ii = opts_len - 1; ii >= 0; ii--) {
                            p = opts_arr[ii].split(':');

                            if (p.length === 2) {
                                opts[$.trim(p[0])] = $.trim(p[1]);
                            }
                        }
                        settings.tipSettings = $.extend({}, settings, opts);
                        settings.tipSettings.tipLocationPattern = settings.tipLocationPatterns[settings.tipSettings.tipLocation];

                        if(settings.modal && settings.expose){
                            methods.expose();
                        }

                        // scroll if not modal
                        if (!/body/i.test(settings.$target.selector) && settings.scroll) {
                            methods.scroll_to();
                        }

                        if (methods.is_phone()) {
                            methods.pos_phone(true);
                        } else {
                            methods.pos_default(true);
                        }

                        $timer = $('.joyride-timer-indicator', settings.$next_tip);

                        if (/pop/i.test(settings.tipAnimation)) {

                            $timer.outerWidth(0);

                            if (settings.timer > 0) {

                                settings.$next_tip.show();
                                $timer.animate({
                                    width: $('.joyride-timer-indicator-wrap', settings.$next_tip).outerWidth()
                                }, settings.timer);

                            } else {

                                settings.$next_tip.show();

                            }


                        } else if (/fade/i.test(settings.tipAnimation)) {

                            $timer.outerWidth(0);

                            if (settings.timer > 0) {

                                settings.$next_tip.fadeIn(settings.tipAnimationFadeSpeed);

                                settings.$next_tip.show();
                                $timer.animate({
                                    width: $('.joyride-timer-indicator-wrap', settings.$next_tip).outerWidth()
                                }, settings.timer);

                            } else {

                                settings.$next_tip.fadeIn(settings.tipAnimationFadeSpeed);

                            }
                        }

                        settings.$current_tip = settings.$next_tip;
                        // Focus next button for keyboard users.
                        $('.joyride-next-tip', settings.$current_tip).focus();
                        methods.tabbable(settings.$current_tip);
                        // skip non-existent targets
                    } else if (settings.$li && settings.$target.length < 1) {

                        methods.show();

                    } else {

                        methods.end();

                    }
                } else {

                    settings.paused = true;

                }

            },

            // detect phones with media queries if supported.
            is_phone : function () {
                if (Modernizr) {
                    return Modernizr.mq('only screen and (max-width: 767px)');
                }

                return (settings.$window.width() < 767) ? true : false;
            },

            support_localstorage : function () {
                if (Modernizr) {
                    return Modernizr.localstorage;
                } else {
                    return !!window.localStorage;
                }
            },

            hide : function () {
                if(settings.modal && settings.expose){
                    methods.un_expose();
                }
                if(!settings.modal){
                    $('.joyride-modal-bg').hide();
                }
                settings.$current_tip.hide();
                settings.postStepCallback(settings.$li.index(), settings.$current_tip);
            },

            set_li : function (init) {
                if (init) {
                    settings.$li = settings.$tip_content.eq(settings.startOffset);
                    methods.set_next_tip();
                    settings.$current_tip = settings.$next_tip;
                } else {
                    settings.$li = settings.$li.next();
                    methods.set_next_tip();
                }

                methods.set_target();
            },

            set_next_tip : function () {
                settings.$next_tip = $('.joyride-tip-guide[data-index=' + settings.$li.index() + ']');
            },

            set_target : function () {
                var cl = settings.$li.attr('data-class'),
                    id = settings.$li.attr('data-id'),
                    $sel = function () {
                        if (id) {
                            return $(settings.document.getElementById(id));
                        } else if (cl) {
                            return $('.' + cl).filter(":visible").first();
                        } else {
                            return $('body');
                        }
                    };

                settings.$target = $sel();
            },

            scroll_to : function () {
                var window_half, tipOffset;

                window_half = settings.$window.height() / 2;
                tipOffset = Math.ceil(settings.$target.offset().top - window_half + settings.$next_tip.outerHeight());

                $("html, body").stop().animate({
                    scrollTop: tipOffset
                }, settings.scrollSpeed);
            },

            paused : function () {
                if (($.inArray((settings.$li.index() + 1), settings.pauseAfter) === -1)) {
                    return true;
                }

                return false;
            },

            destroy : function () {
                if(!$.isEmptyObject(settings)){
                    settings.$document.off('.joyride');
                }

                $(window).off('.joyride');
                $('.joyride-close-tip, .joyride-next-tip, .joyride-modal-bg').off('.joyride');
                $('.joyride-tip-guide, .joyride-modal-bg').remove();
                clearTimeout(settings.automate);
                settings = {};
            },

            restart : function () {
                if(!settings.autoStart)
                {
                    if (!settings.startTimerOnClick && settings.timer > 0) {
                        methods.show('init');
                        methods.startTimer();
                    } else {
                        methods.show('init');
                    }
                    settings.autoStart = true;
                }
                else
                {
                    methods.hide();
                    settings.$li = undefined;
                    methods.show('init');
                }
            },

            pos_default : function (init) {
                var half_fold = Math.ceil(settings.$window.height() / 2),
                    tip_position = settings.$next_tip.offset(),
                    $nub = $('.joyride-nub', settings.$next_tip),
                    nub_width = Math.ceil($nub.outerWidth() / 2),
                    nub_height = Math.ceil($nub.outerHeight() / 2),
                    toggle = init || false;

                // tip must not be "display: none" to calculate position
                if (toggle) {
                    settings.$next_tip.css('visibility', 'hidden');
                    settings.$next_tip.show();
                }

                if (!/body/i.test(settings.$target.selector)) {
                    var
                        topAdjustment = settings.tipSettings.tipAdjustmentY ? parseInt(settings.tipSettings.tipAdjustmentY) : 0,
                        leftAdjustment = settings.tipSettings.tipAdjustmentX ? parseInt(settings.tipSettings.tipAdjustmentX) : 0;

                    if (methods.bottom()) {
                        settings.$next_tip.css({
                            top: (settings.$target.offset().top + nub_height + settings.$target.outerHeight() + topAdjustment),
                            left: settings.$target.offset().left + leftAdjustment});

                        if (/right/i.test(settings.tipSettings.nubPosition)) {
                            settings.$next_tip.css('left', settings.$target.offset().left - settings.$next_tip.outerWidth() + settings.$target.outerWidth());
                        }

                        methods.nub_position($nub, settings.tipSettings.nubPosition, 'top');

                    } else if (methods.top()) {

                        settings.$next_tip.css({
                            top: (settings.$target.offset().top - settings.$next_tip.outerHeight() - nub_height + topAdjustment),
                            left: settings.$target.offset().left + leftAdjustment});

                        methods.nub_position($nub, settings.tipSettings.nubPosition, 'bottom');

                    } else if (methods.right()) {

                        settings.$next_tip.css({
                            top: settings.$target.offset().top + topAdjustment,
                            left: (settings.$target.outerWidth() + settings.$target.offset().left + nub_width) + leftAdjustment});

                        methods.nub_position($nub, settings.tipSettings.nubPosition, 'left');

                    } else if (methods.left()) {

                        settings.$next_tip.css({
                            top: settings.$target.offset().top + topAdjustment,
                            left: (settings.$target.offset().left - settings.$next_tip.outerWidth() - nub_width) + leftAdjustment});

                        methods.nub_position($nub, settings.tipSettings.nubPosition, 'right');

                    }

                    if (!methods.visible(methods.corners(settings.$next_tip)) && settings.attempts < settings.tipSettings.tipLocationPattern.length) {

                        $nub.removeClass('bottom')
                            .removeClass('top')
                            .removeClass('right')
                            .removeClass('left');

                        settings.tipSettings.tipLocation = settings.tipSettings.tipLocationPattern[settings.attempts];

                        settings.attempts++;

                        methods.pos_default(true);

                    }

                } else if (settings.$li.length) {

                    methods.pos_modal($nub);

                }

                if (toggle) {
                    settings.$next_tip.hide();
                    settings.$next_tip.css('visibility', 'visible');
                }

            },

            pos_phone : function (init) {
                var tip_height = settings.$next_tip.outerHeight(),
                    tip_offset = settings.$next_tip.offset(),
                    target_height = settings.$target.outerHeight(),
                    $nub = $('.joyride-nub', settings.$next_tip),
                    nub_height = Math.ceil($nub.outerHeight() / 2),
                    toggle = init || false;

                $nub.removeClass('bottom')
                    .removeClass('top')
                    .removeClass('right')
                    .removeClass('left');

                if (toggle) {
                    settings.$next_tip.css('visibility', 'hidden');
                    settings.$next_tip.show();
                }

                if (!/body/i.test(settings.$target.selector)) {

                    if (methods.top()) {

                        settings.$next_tip.offset({top: settings.$target.offset().top - tip_height - nub_height});
                        $nub.addClass('bottom');

                    } else {

                        settings.$next_tip.offset({top: settings.$target.offset().top + target_height + nub_height});
                        $nub.addClass('top');

                    }

                } else if (settings.$li.length) {

                    methods.pos_modal($nub);

                }

                if (toggle) {
                    settings.$next_tip.hide();
                    settings.$next_tip.css('visibility', 'visible');
                }
            },

            pos_modal : function ($nub) {
                methods.center();
                $nub.hide();

                methods.show_modal();

            },

            show_modal : function() {
                if ($('.joyride-modal-bg').length < 1) {
                    $('body').append(settings.template.modal).show();
                }

                if (/pop/i.test(settings.tipAnimation)) {
                    $('.joyride-modal-bg').show();
                } else {
                    $('.joyride-modal-bg').fadeIn(settings.tipAnimationFadeSpeed);
                }
            },

            expose: function(){
                var expose,
                    exposeCover,
                    el,
                    origCSS,
                    randId = 'expose-'+Math.floor(Math.random()*10000);
                if (arguments.length>0 && arguments[0] instanceof $){
                    el = arguments[0];
                } else if(settings.$target && !/body/i.test(settings.$target.selector)){
                    el = settings.$target;
                }  else {
                    return false;
                }
                if(el.length < 1){
                    if(window.console){
                        console.error('element not valid', el);
                    }
                    return false;
                }
                expose = $(settings.template.expose);
                settings.$body.append(expose);
                expose.css({
                    top: el.offset().top,
                    left: el.offset().left,
                    width: el.outerWidth(true),
                    height: el.outerHeight(true)
                });
                exposeCover = $(settings.template.exposeCover);
                origCSS = {
                    zIndex: el.css('z-index'),
                    position: el.css('position')
                };
                el.css('z-index',expose.css('z-index')*1+1);
                if(origCSS.position == 'static'){
                    el.css('position','relative');
                }
                el.data('expose-css',origCSS);
                exposeCover.css({
                    top: el.offset().top,
                    left: el.offset().left,
                    width: el.outerWidth(true),
                    height: el.outerHeight(true)
                });
                settings.$body.append(exposeCover);
                expose.addClass(randId);
                exposeCover.addClass(randId);
                if(settings.tipSettings['exposeClass']){
                    expose.addClass(settings.tipSettings['exposeClass']);
                    exposeCover.addClass(settings.tipSettings['exposeClass']);
                }
                el.data('expose', randId);
                settings.postExposeCallback(settings.$li.index(), settings.$next_tip, el);
                methods.add_exposed(el);
            },

            un_expose: function(){
                var exposeId,
                    el,
                    expose ,
                    origCSS,
                    clearAll = false;
                if (arguments.length>0 && arguments[0] instanceof $){
                    el = arguments[0];
                } else if(settings.$target && !/body/i.test(settings.$target.selector)){
                    el = settings.$target;
                }  else {
                    return false;
                }
                if(el.length < 1){
                    if(window.console){
                        console.error('element not valid', el);
                    }
                    return false;
                }
                exposeId = el.data('expose');
                expose = $('.'+exposeId);
                if(arguments.length>1){
                    clearAll = arguments[1];
                }
                if(clearAll === true){
                    $('.joyride-expose-wrapper,.joyride-expose-cover').remove();
                } else {
                    expose.remove();
                }
                origCSS = el.data('expose-css');
                if(origCSS.zIndex == 'auto'){
                    el.css('z-index', '');
                } else {
                    el.css('z-index',origCSS.zIndex);
                }
                if(origCSS.position != el.css('position')){
                    if(origCSS.position == 'static'){// this is default, no need to set it.
                        el.css('position', '');
                    } else {
                        el.css('position',origCSS.position);
                    }
                }
                el.removeData('expose');
                el.removeData('expose-z-index');
                methods.remove_exposed(el);
            },

            add_exposed: function(el){
                settings.exposed = settings.exposed || [];
                if(el instanceof $){
                    settings.exposed.push(el[0]);
                } else if(typeof el == 'string'){
                    settings.exposed.push(el);
                }
            },

            remove_exposed: function(el){
                var search;
                if(el instanceof $){
                    search = el[0]
                } else if (typeof el == 'string'){
                    search = el;
                }
                settings.exposed = settings.exposed || [];
                for(var i=0; i<settings.exposed.length; i++){
                    if(settings.exposed[i] == search){
                        settings.exposed.splice(i,1);
                        return;
                    }
                }
            },

            center : function () {
                var $w = settings.$window;

                settings.$next_tip.css({
                    top : ((($w.height() - settings.$next_tip.outerHeight()) / 2) + $w.scrollTop()),
                    left : ((($w.width() - settings.$next_tip.outerWidth()) / 2) + $w.scrollLeft())
                });

                return true;
            },

            bottom : function () {
                return /bottom/i.test(settings.tipSettings.tipLocation);
            },

            top : function () {
                return /top/i.test(settings.tipSettings.tipLocation);
            },

            right : function () {
                return /right/i.test(settings.tipSettings.tipLocation);
            },

            left : function () {
                return /left/i.test(settings.tipSettings.tipLocation);
            },

            corners : function (el) {
                var w = settings.$window,
                    window_half = w.height() / 2,
                    tipOffset = Math.ceil(settings.$target.offset().top - window_half + settings.$next_tip.outerHeight()),//using this to calculate since scroll may not have finished yet.
                    right = w.width() + w.scrollLeft(),
                    offsetBottom =  w.height() + tipOffset,
                    bottom = w.height() + w.scrollTop(),
                    top = w.scrollTop();

                if(tipOffset < top){
                    if (tipOffset <0 ){
                        top = 0;
                    } else {
                        top = tipOffset;
                    }
                }

                if(offsetBottom > bottom){
                    bottom = offsetBottom;
                }

                return [
                    el.offset().top < top,
                    right < el.offset().left + el.outerWidth(),
                    bottom < el.offset().top + el.outerHeight(),
                    w.scrollLeft() > el.offset().left
                ];
            },

            visible : function (hidden_corners) {
                var i = hidden_corners.length;

                while (i--) {
                    if (hidden_corners[i]) return false;
                }

                return true;
            },

            nub_position : function (nub, pos, def) {
                if (pos === 'auto') {
                    nub.addClass(def);
                } else {
                    nub.addClass(pos);
                }
            },

            startTimer : function () {
                if (settings.$li.length) {
                    settings.automate = setTimeout(function () {
                        methods.hide();
                        methods.show();
                        methods.startTimer();
                    }, settings.timer);
                } else {
                    clearTimeout(settings.automate);
                }
            },

            end : function () {
                if (settings.cookieMonster) {
                    $.cookie(settings.cookieName, 'ridden', { expires: 365, domain: settings.cookieDomain, path: settings.cookiePath });
                }

                if (settings.localStorage) {
                    localStorage.setItem(settings.localStorageKey, true);
                }

                if (settings.timer > 0) {
                    clearTimeout(settings.automate);
                }
                if(settings.modal && settings.expose){
                    methods.un_expose();
                }
                if (settings.$current_tip) {
                    settings.$current_tip.hide();
                }
                if (settings.$li) {
                    settings.postStepCallback(settings.$li.index(), settings.$current_tip);
                    settings.postRideCallback(settings.$li.index(), settings.$current_tip);
                }
                $('.joyride-modal-bg').hide();
            },

            jquery_check : function () {
                // define on() and off() for older jQuery
                if (!$.isFunction($.fn.on)) {

                    $.fn.on = function (types, sel, fn) {

                        return this.delegate(sel, types, fn);

                    };

                    $.fn.off = function (types, sel, fn) {

                        return this.undelegate(sel, types, fn);

                    };

                    return false;
                }

                return true;
            },

            outerHTML : function (el) {
                // support FireFox < 11
                return el.outerHTML || new XMLSerializer().serializeToString(el);
            },

            version : function () {
                return settings.version;
            },

            tabbable : function (el) {
                $(el).on('keydown', function( event ) {
                    if (!event.isDefaultPrevented() && event.keyCode &&
                        // Escape key.
                        event.keyCode === 27 ) {
                        event.preventDefault();
                        methods.end();
                        return;
                    }

                    // Prevent tabbing out of tour items.
                    if ( event.keyCode !== 9 ) {
                        return;
                    }
                    var tabbables = $(el).find(":tabbable"),
                        first = tabbables.filter(":first"),
                        last  = tabbables.filter(":last");
                    if ( event.target === last[0] && !event.shiftKey ) {
                        first.focus( 1 );
                        event.preventDefault();
                    } else if ( event.target === first[0] && event.shiftKey ) {
                        last.focus( 1 );
                        event.preventDefault();
                    }
                });
            }

        };

    $.fn.joyride = function (method) {
        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('Method ' +  method + ' does not exist on jQuery.joyride');
        }
    };

}(jQuery, this));